61 research outputs found
Generic Search Plans for Matching Advanced Graph Patterns
In the current paper, we present search plans which can guide pattern
matching for advanced graph patterns with edge identities, containment
constraints, type variables, negative application conditions, attribute
conditions, and injectivity constraints. Based on a generic search graph
representation, all search plan operations (e.g. checking the existence of
an edge, or extending a matching candidate by navigating along an edge) are
uniformly represented as special predicates with heuristically assigned
costs. Finally, an executable search plan is defined as an appropriate
ordering of these predicates. As a main consequence, attribute, injectivity,
and negative application conditions can be checked early (but not
unnecessarily early) in the pattern matching process to cut off infeasible
matching candidates at the right time
Designing the automatic transformation of visual languages
AbstractThe design process of complex systems requires a precise checking of the functional and dependability attributes of the target design. The growing complexity of systems necessitates the use of formal methods, as the exhaustiveness of checks performed by the traditional simulation and testing is insufficient.For this reason, the mathematical models of various formal verification tools are automatically derived from UML-diagrams of the model by mathematical transformations guaranteeing a complete consistency between the target design and the models of verification and validation tools.In the current paper, a general framework for an automated model transformation system is presented. The method starts from a uniform visual description and a formal proof concept of the particular transformations by integrating the powerful computational paradigm of graph transformation, planner algorithms of artificial intelligence, and various concepts of computer engineering
Incremental Graph Pattern Matching: Data Structures and Initial Experiments
Despite the large variety of existing graph transformation tools, the implementation of their pattern matching engine typically follows the same principle. First a matching occurrence of the left-hand side of the graph transformation rule is searched by some graph pattern matching algorithm. Then potential negative application conditions are checked that might eliminate the previous occurrence. However, when a new transformation step is started, all the information on previous matchings is lost, and the complex graph pattern matching phase is restarted from scratch each time. In the paper, we present the foundational data structures and initial experiments for an incremental graph pattern matching engine which keeps track of existing matchings in an incremental way to reduce the execution time of graph pattern matching
Generating Preconditions from Graph Constraints by Higher Order Graph Transformation
Techniques for the verification of structural invariants in graph transformation systems typically rely on the derivation of negative application conditions that are attached to graph transformation rules in order to avoid the runtime occurrence of forbidden structural patterns in the system model. In this paper, we propose a practical approach for this derivation process, which produces the required negative application conditions by applying higher order graph transformation on the rule specifications themselves. Additionally, we integrate filtering criteria into these higher order constructs to avoid already at an early stage the unnecessary construction of invalid and redundant rules with negative application conditions
Conflict Detection for Edits on Extended Feature Models using Symbolic Graph Transformation
Feature models are used to specify variability of user-configurable systems
as appearing, e.g., in software product lines. Software product lines are
supposed to be long-living and, therefore, have to continuously evolve over
time to meet ever-changing requirements. Evolution imposes changes to feature
models in terms of edit operations. Ensuring consistency of concurrent edits
requires appropriate conflict detection techniques. However, recent approaches
fail to handle crucial subtleties of extended feature models, namely
constraints mixing feature-tree patterns with first-order logic formulas over
non-Boolean feature attributes with potentially infinite value domains. In this
paper, we propose a novel conflict detection approach based on symbolic graph
transformation to facilitate concurrent edits on extended feature models. We
describe extended feature models formally with symbolic graphs and edit
operations with symbolic graph transformation rules combining graph patterns
with first-order logic formulas. The approach is implemented by combining
eMoflon with an SMT solver, and evaluated with respect to applicability.Comment: In Proceedings FMSPLE 2016, arXiv:1603.0857
Improved Conflict Detection for Graph Transformation with Attributes
In graph transformation, a conflict describes a situation where two
alternative transformations cannot be arbitrarily serialized. When enriching
graphs with attributes, existing conflict detection techniques typically report
a conflict whenever at least one of two transformations manipulates a shared
attribute. In this paper, we propose an improved, less conservative condition
for static conflict detection of graph transformation with attributes by
explicitly taking the semantics of the attribute operations into account. The
proposed technique is based on symbolic graphs, which extend the traditional
notion of graphs by logic formulas used for attribute handling. The approach is
proven complete, i.e., any potential conflict is guaranteed to be detected.Comment: In Proceedings GaM 2015, arXiv:1504.0244
Complex Attribute Manipulation in TGGs with Constraint-Based Programming Techniques
Model transformation plays a central role in Model-Driven Engineering (MDE) and providing bidirectional transformation languages is a current challenge with important applications. Triple Graph Grammars (TGGs) are a formally founded, bidirectional model transformation language shown by numerous case studies to be quite promising and successful. Although TGGs provide adequate support for structural aspects via object patterns in TGG rules, support for handling complex relationships between different attributes is still missing in current implementations. For certain applications, such as bidirectional model-to-text transformations, being able to manipulate attributes via string manipulation or arithmetic operations in TGG rules is vital. Our contribution in this paper is to formalize a TGG extension that provides a means for complex attribute manipulation in TGG rules. Our extension is compatible with the existing TGG formalization, and retains the "single specification'' philosophy of TGGs
A Systematic Approach to Constructing Incremental Topology Control Algorithms Using Graph Transformation
Communication networks form the backbone of our society. Topology control
algorithms optimize the topology of such communication networks. Due to the
importance of communication networks, a topology control algorithm should
guarantee certain required consistency properties (e.g., connectivity of the
topology), while achieving desired optimization properties (e.g., a bounded
number of neighbors). Real-world topologies are dynamic (e.g., because nodes
join, leave, or move within the network), which requires topology control
algorithms to operate in an incremental way, i.e., based on the recently
introduced modifications of a topology. Visual programming and specification
languages are a proven means for specifying the structure as well as
consistency and optimization properties of topologies. In this paper, we
present a novel methodology, based on a visual graph transformation and graph
constraint language, for developing incremental topology control algorithms
that are guaranteed to fulfill a set of specified consistency and optimization
constraints. More specifically, we model the possible modifications of a
topology control algorithm and the environment using graph transformation
rules, and we describe consistency and optimization properties using graph
constraints. On this basis, we apply and extend a well-known constructive
approach to derive refined graph transformation rules that preserve these graph
constraints. We apply our methodology to re-engineer an established topology
control algorithm, kTC, and evaluate it in a network simulation study to show
the practical applicability of our approachComment: This document corresponds to the accepted manuscript of the
referenced journal articl
A Systematic Approach to Constructing Families of Incremental Topology Control Algorithms Using Graph Transformation
In the communication systems domain, constructing and maintaining network
topologies via topology control (TC) algorithms is an important cross-cutting
research area. Network topologies are usually modeled using attributed graphs
whose nodes and edges represent the network nodes and their interconnecting
links. A key requirement of TC algorithms is to fulfill certain consistency and
optimization properties to ensure a high quality of service. Still, few
attempts have been made to constructively integrate these properties into the
development process of TC algorithms. Furthermore, even though many TC
algorithms share substantial parts (such as structural patterns or tie-breaking
strategies), few works constructively leverage these commonalities and
differences of TC algorithms systematically. In previous work, we addressed the
constructive integration of consistency properties into the development
process. We outlined a constructive, model-driven methodology for designing
individual TC algorithms. Valid and high-quality topologies are characterized
using declarative graph constraints; TC algorithms are specified using
programmed graph transformation. We applied a well-known static analysis
technique to refine a given TC algorithm in a way that the resulting algorithm
preserves the specified graph constraints.
In this paper, we extend our constructive methodology by generalizing it to
support the specification of families of TC algorithms. To show the feasibility
of our approach, we reneging six existing TC algorithms and develop e-kTC, a
novel energy-efficient variant of the TC algorithm kTC. Finally, we evaluate a
subset of the specified TC algorithms using a new tool integration of the graph
transformation tool eMoflon and the Simonstrator network simulation framework.Comment: Corresponds to the accepted manuscrip
- …